home *** CD-ROM | disk | FTP | other *** search
/ GameStar 2004 April / Gamestar_61_2004-04_dvdb.iso / DVDStar / Editace / hltp.exe / {app} / Applications / QuArK / plugins / mapmovevertex.py < prev    next >
Text File  |  2004-01-05  |  30KB  |  914 lines
  1. """   QuArK  -  Quake Army Knife
  2.  
  3. Vertex moveing plugin
  4. """
  5.  
  6. #
  7. # THIS FILE IS PROTECTED BY THE GNU GENERAL PUBLIC LICENCE
  8. # FOUND IN FILE "COPYING.TXT"
  9. #
  10.  
  11. # $Header: /cvsroot/quark/runtime/plugins/mapmovevertex.py,v 1.7 2002/05/18 22:38:31 tiglari Exp $
  12.  
  13. Info = {
  14.    "plug-in":       "Vertex Movement Dialog",
  15.    "desc":          "dialg for moving vertexes",
  16.    "date":          "22 Sep 2000",
  17.    "author":        "tiglari",
  18.    "author e-mail": "tiglari@hexenworld.net",
  19.    "quark":         "Version 6.x" }
  20.  
  21.  
  22. #
  23. # The import statements make material in other files available
  24. #  to the statements in this file
  25. #
  26.  
  27. #
  28. # Quarkx is the delphi-defined API
  29. #
  30. import quarkx
  31.  
  32. #
  33. # This imports the maphandles.py file in the quarkpy folder
  34. #  To use something from this file you need to `quality' its
  35. #  name with quarkpy.maphandles, e.g. `quarkpy.maphandles.VertexHandle`
  36. # 
  37. import quarkpy.maphandles
  38.  
  39. #
  40. # for face menu options
  41. #
  42. import quarkpy.mapoptions
  43.  
  44. #
  45. # This imports the tagging.py plugin in this folder
  46. #
  47. import tagging
  48.  
  49. #
  50. # This imports every function in quarkpy\maputils
  51. #  things imported in this way don't need to be (& in fact
  52. #  can't be) qualified
  53. #
  54. from quarkpy.maputils import *
  55.  
  56. #
  57. # For the stuff below about moving some object containing a vertex
  58. #
  59. from quarkpy import guiutils
  60.  
  61. #
  62. # repeated from maputils to make it work with older quark versions.
  63. #
  64.  
  65. def projectpointtoplane(p,n1,o2,n2):
  66.   "project point to plane at o2 with normal n2 along normal n1"
  67.   v1 = o2-p
  68.   v2 = v1*n2
  69.   v3 = n1*n2
  70.   v4 = v2/v3
  71.   v5 = v4*n1
  72.   return p + v5
  73.  
  74. #
  75. # A utility for accessing attributes of objects
  76. #  (class instances) that might not be defined
  77. #
  78. def getAttr(object, attr, default=None):
  79.     if hasattr(object, attr):
  80.         return getattr(object,attr)
  81.     else:
  82.         return default
  83. #
  84. # ditto for deleting attributes
  85. #
  86. def delAttr(object, attr):
  87.     if hasattr(object, attr):
  88.          delattr(object, attr)
  89.  
  90. def appendToAttr(object, attr, thing):
  91.     if hasattr(object, attr):
  92.         getattr(object,attr).append(thing)
  93.     else:
  94.         setattr(object,attr,[thing])
  95.  
  96. def removeFromAttr(object, attr, thing):
  97.     getattr(object,attr).remove(thing)
  98.     if getattr(object,attr)==[]:
  99.         delattr(object,attr)
  100. #
  101. # This is a definition of the vertex-movement dialog
  102. # The `live edit dialog' is a rather fancy critter defined
  103. #  in quarkpy/dlgclasses.  Don't worry about its innards,
  104. #  but you'll see how it's used further below.
  105. #
  106. # Read http://..adv.quarkpy.gui.html#dialogs in the infobase
  107. #  for details on how this stuff defines the appearance of
  108. #  dialog and the data-entry forms in it.
  109. #
  110. #  `EU` is the form with a field that you can enter a numerical
  111. #   value, and up-down buttons for increment/decrement
  112. #
  113. #  Somebody has really gotta gettaroundto documenting all the
  114. #   different Typ's...
  115. #
  116.  
  117. class VtxDragDlg(quarkpy.dlgclasses.LiveEditDlg):
  118.     #
  119.     # dialog layout
  120.     #
  121.  
  122.     endcolor = AQUA
  123.     size = (140,120)
  124.     dfsep = 0.50
  125.  
  126.     dlgdef = """
  127.         {
  128.             Style = "9"
  129.         Caption = "Vertex Movement"
  130.  
  131.         X: = 
  132.         {
  133.         Txt = "X"
  134.         Typ = "EU"
  135.         Hint = "X position"
  136.         }
  137.  
  138.         Y: = 
  139.         {
  140.         Txt = "Y"
  141.         Typ = "EU"
  142.         Hint = "Y position"
  143.         }
  144.  
  145.         Z: = 
  146.         {
  147.         Txt = "Z"
  148.         Typ = "EU"
  149.         Hint = "Z position"
  150.         }
  151.  
  152.         sep: = { Typ="S" Txt=" " }
  153.  
  154.         gridpos: =
  155.         {
  156.         Txt = "Grid Position"
  157.         Typ="X"
  158.         Hint="If this is checked, vertexes will move to grid positions"
  159.         }
  160.         
  161.         griddel: =
  162.         {
  163.         Txt = "Grid Delta"
  164.         Typ="X"
  165.         Hint="If this is checked, vertexes will move by grid increments" $0D " (overridden by Grid Position)"
  166.         }
  167.  
  168.         sloppy: =
  169.         {
  170.         Txt = "Sloppy"
  171.         Typ="X"
  172.         Hint="If this is checked, vertexes move in the plane of a locked face, but not necessarily to where you specify"
  173.         }
  174.  
  175.         sep: = { Typ="S" Txt=""}
  176.  
  177.         exit:py = {Txt="" }
  178.     }
  179.     """
  180.  
  181. #
  182. # Main math function.  Might shift into maputils.
  183. #
  184. def rotateFace(face, mvtx, delta, pivot, pivot2):
  185.     "rotates face from mvtx by delta around pivots"
  186. #    debug('delta: '+`delta`)
  187.     #
  188.     # Much more laborious than Tim Smith's maphandles
  189.     #  method, but seems to prevent `drifting' of supposedly
  190.     #  locked vertices from their locked positions
  191.     #
  192.     # The idea if first to use the pivots and
  193.     #  the new position as threepoints, then fix up
  194.     #  the texture by rotating the texture threepoints,
  195.     #  (code 3), and projecting them onto the new face.
  196.     #
  197.     # Probably a more streamlined approach will work, but
  198.     #  the drifting problem is a pain.
  199.     #
  200.     rotationAxis = (pivot2-pivot).normalized
  201.     norm1 = (rotationAxis^(mvtx-pivot)).normalized
  202.     plane1 = rotationAxis^norm1
  203.     norm2 = (rotationAxis^(mvtx+delta-pivot)).normalized
  204.     plane2 = rotationAxis^norm2
  205.     points = face.threepoints(3)
  206.     facenorm = face.normal
  207.     def proj(v, org=pivot, ax1=rotationAxis, ax2=plane1):
  208.         return (v-org)*ax1, (v-org)*ax2
  209.     #
  210.     # map applies proj to each member in the tuple `points',
  211.     #  producing the new tuple `pcoords'
  212.     #
  213.     pcoords = map(proj, points)
  214.     face.setthreepoints((pivot2, pivot, mvtx+delta),0)
  215.     if facenorm*face.normal<0:
  216.         face.swapsides()
  217.     newpoints = face.threepoints(0)
  218.     def proj2plane(p,pp=newpoints[1],nn=face.normal):
  219.         return projectpointtoplane(p,nn,pp,nn)
  220.     def unproj((x, y),org=pivot,ax1=rotationAxis, ax2=plane2):
  221.         return org+x*ax1+y*ax2
  222.     #
  223.     # Well I could have piled up three maps, and not
  224.     #  used the pcoords variable, but I didn't!
  225.     #
  226.     newpoints = tuple(map(proj2plane, (map(unproj, pcoords))))
  227.     face.setthreepoints(newpoints,3)
  228.     
  229.  
  230. #
  231. # Here's the function that does the real work of moving the faces.
  232. # It's a good idea to separate out the functions & classes that
  233. #  perform significant work on the data being manipulated from
  234. #  those that are basically oriented towards the UI
  235. #
  236. def moveFaces(faces, mvtx, delta, poly, locklist, freezelist, sloppy=None):
  237.     "returns the moving old, new faces, of poly , with mvtx moved by delta"
  238.     result = []
  239.     old = []
  240.     for face in faces:
  241.         if face in freezelist:
  242.             continue
  243.         newface = face.copy()
  244.         norm = face.normal
  245.         facelocked = []
  246.         #
  247.         # regular index method doesn't work for lists of vectors
  248.         #
  249.         vtxes = face.verticesof(poly)
  250.         vtxindex = 0
  251.         for vtx in vtxes:
  252.             if not(vtx-mvtx):
  253.                 moveindex = vtxindex   
  254.             for vtxh in locklist:
  255.                 #
  256.                 # Testing for closeness rather than full-precision
  257.                 #  superposition seems to be necessary to keep the
  258.                 #  locked vertices from coming adrift.  There's
  259.                 #  no theory behind the choice of value; it just
  260.                 #  seems to work.
  261.                 #
  262.                 if (vtxh.poly is poly and abs(vtxh.pos-vtx)<.1):
  263.                     facelocked.append(vtxh.pos)
  264.                     #
  265.                     # we only use this if only one vertex is locked
  266.                     #
  267.                     lockindex=vtxindex
  268.                 vtxindex=vtxindex+1
  269.         if len(facelocked) == 0:
  270.             proj = delta*norm
  271.             newface.translate(proj*norm)
  272. #            debug('translated '+newface.shortname)    
  273.         if len(facelocked) == 1:
  274.             #
  275.             # this autolock stuff isn't working right so its
  276.             #  dialog checkbox is commented out to disableit
  277.             #
  278.             if 0:
  279. #            if autolock:
  280.                 cyclelength = len(vtxes)
  281.                 if cyclelength/abs(moveindex-lockindex)!=2:
  282.                     #
  283.                     # I think a mathematician could do this better
  284.                     #
  285.                     halfcycle = cyclelength/2.0
  286.                     if moveindex<lockindex:
  287.                         if lockindex-moveindex<halfcycle:
  288.                             secondlockindex=lockindex+1
  289.                         else:
  290.                             secondlockindex=lockindex-1
  291.                     elif lockindex<moveindex:
  292.                         if moveindex-lockindex<halfcycle:
  293.                             secondlockindex=lockindex-1
  294.                         else:
  295.                             secondlockindex=lockindex+1
  296.                     #
  297.                     # the remainder operation is the go for cyclic
  298.                     #  indexing situations.
  299.                     #
  300.                     facelocked.append(vtxes[secondlockindex%cyclelength])
  301.         if len(facelocked)==1:        
  302.                 #
  303.                 # rotate around perp to line from mftx to pivot
  304.                 #
  305.                 pivot=facelocked[0]
  306.                 perp = newface.normal^(mvtx-pivot)
  307.                 rotateFace(newface, mvtx, delta, pivot, pivot+perp)
  308.         if len(facelocked) == 2:
  309.             rotateFace(newface, mvtx, delta, facelocked[0], facelocked[1])
  310. #            debug('2-rotated '+newface.shortname)
  311.         if len(facelocked) > 2:
  312.             if sloppy:
  313.                 continue
  314.             norm = face.normal
  315.             #
  316.             # Bail unless the new vertex position is on the
  317.             #  fully locked plane.
  318.             #
  319.             if norm*(mvtx+delta-facelocked[0]):
  320.                 return None, None
  321.         old.append(face)
  322.         result.append(newface)
  323.     return old, result
  324.  
  325. #
  326. # Now we get going on the interface.
  327. #
  328.  
  329. #
  330. # First define a new menu (see the plugins tutorial for the
  331. #  general method)
  332. #
  333. def vertexmenu(self, editor, view, oldmenu=quarkpy.maphandles.VertexHandle.menu.im_func):
  334.  
  335.     #
  336.     # This is a very convenient approach to defining the `callback'
  337.     #  functions that are called when a menu-item is clicked; the
  338.     #  default-argument specifications make it easy to pass all
  339.     #  sorts of info to the functions (e.g. self in the function
  340.     #  is equated to self in the environment).
  341.     # Won't work for callbacks that want to also be called from
  342.     #  the command menu or a toolbar button (like some of the ones
  343.     #  in maptagside)
  344.     #
  345.     def moveclick(n, self=self, editor=editor):
  346.          pos = self.pos
  347.          poly = self.poly
  348.          faces = poly.faces
  349.          #
  350.          # find out what faces are going to move
  351.          #
  352.          moving = []
  353.          for face in faces:
  354.              for vtx in face.verticesof(poly):
  355.                  #
  356.                  # Remember = doesn't work right for vectors;
  357.                  #  this is how you test for two vectors being
  358.                  #  equal
  359.                  #
  360.                  if not (vtx-pos):
  361.                     moving.append(face)
  362.                     continue
  363.     
  364.          #
  365.          # Now start setting up the live edit dialog; this is
  366.          #  a black magic process that you just follow
  367.          #
  368.          
  369.          #
  370.          #  The objects that the dialog is going to manipulate
  371.          #   are stuffed into a `pack' object
  372.          #
  373.          class pack:
  374.              "a place to stick stuff"
  375.          pack.poly = poly
  376.          pack.moving = moving
  377.          pack.pos = pos
  378.  
  379.          #
  380.          # Now define a setup function with `self' as its first
  381.          #  argument, and any number of further default arguments
  382.          #  specified to in stuff from above. 
  383.          #
  384.          # `self' refers the dialog, it's .src is the object
  385.          #  from which the displayed values in the dialog are
  386.          #  taken
  387.          #
  388.          def setup(self, pack=pack, editor=editor):
  389.              src = self.src
  390.              options = quarkx.setupsubset(SS_MAP, "Options")
  391.              src["gridpos"]=options["movevertex_gridpos"]
  392.              src["griddel"]=options["movevertex_griddel"]
  393.              src["sloppy"]=options["movevertex_sloppy"]
  394.              pos = pack.pos
  395.              #
  396.              # Tell the editor the position of the moving vertex,
  397.              #   so that a green box can be drawn around it
  398.              #
  399.              editor.movingvertex = pos
  400.              editor.invalidateviews()
  401.              #
  402.              # this code loads the x, y and z coordinates,
  403.              #  represented as strings, into the X, Y and Z
  404.              #  specifics of src, and hence ultimately into
  405.              #  the corresponding controls of the dialog
  406.              #
  407.              self.src["X"] = "%f"%pos.x
  408.              self.src["Y"] = "%f"%pos.y
  409.              self.src["Z"] = "%f"%pos.z
  410.              
  411.          #
  412.          # `action' is the function that is called when the
  413.          #   data in the dialog box is changed
  414.          #
  415.          def action(self, pack=pack, editor=editor):
  416.              #
  417.              # read the new data from self.src
  418.              #
  419.              src = self.src
  420.              #
  421.              # Showing off with lambda as well as map. Could be
  422.              # done three statements, in the style of setup above
  423.              #
  424.              x,y,z = map(lambda d,src=src:eval(src[d]),("X","Y","Z"))
  425.              newpos = quarkx.vect(x,y,z)
  426.              #
  427.              # calculate the desired movement, get list of locked
  428.              #  vertices, etc.
  429.              #
  430.              delta = newpos-pack.pos
  431.              #
  432.              # grid stuff
  433.              #
  434.              gridstep = editor.gridstep
  435.              #
  436.              # There's tricky approximation stuff here, just empirical,
  437.              #  I don't understand the math.
  438.              #
  439.              if gridstep:
  440.                  if src["gridpos"]:
  441.                      #
  442.                      # map a delta component
  443.                      #
  444.                      def delcom(d, p, gridstep=gridstep):
  445.                          offgrid = p%gridstep
  446.                          #
  447.                          # or should we force to grid?
  448.                          #
  449.                          if abs(d)<0.01:
  450.                             return 0.0
  451.                          #
  452.                          # little change, increment/decrement
  453.                          #
  454.                          if abs(d)<=1.0:
  455.                              if d>0:
  456.                                  return gridstep-offgrid
  457.                              else:
  458.                                  return -gridstep-offgrid
  459.                          #
  460.                          # otherwise round off change so final
  461.                          #  pozzie goes to nearest gridpoint
  462.                          #
  463.                          offgrid = (p+d)%gridstep
  464.                          if offgrid<(gridstep/2.0):
  465.                              return d-offgrid
  466.                          else:
  467.                              return d+gridstep-offgrid
  468.                  elif src["griddel"]:
  469. #                     debug('griddel')
  470.                      def delcom(d, p, gridstep=gridstep):
  471.                          if abs(d)<.01:
  472.                              return 0.0
  473.                          if abs(d)<=1.0:
  474.                              if d>0:
  475.                                  return gridstep
  476.                              else:
  477.                                  return -gridstep
  478.                          offgrid = d%gridstep
  479.                          if offgrid<(gridstep/2.0):
  480.                              return d-offgrid
  481.                          else:
  482.                              return d+gridstep-offgrid
  483.                  else:
  484.                      def delcom(d, p, gridstep=gridstep):
  485.                          return d
  486. #                 debug('orig delta: '+`delta`)
  487.                  delta = quarkx.vect(tuple(map(delcom,delta.tuple, pack.pos.tuple)))
  488.              oldfaces=pack.moving
  489.              locklist = getAttr(editor,'lockedVertices',[])
  490.              freezelist = getAttr(editor,'frozenFaces',[])
  491.              #
  492.              # calculate the new faces
  493.              #
  494.              oldfaces, newfaces = moveFaces(oldfaces, pack.pos, delta, pack.poly, locklist, freezelist, src["sloppy"])
  495.              #
  496.              # Mere return from function produces None return value.
  497.              #  exceptions would be the way to go if there were
  498.              #  more different kinds of failure to deal with.
  499.              #
  500.              # A `computational' routine such as moveFaces shouldn't
  501.              #  throw up error dialog boxes itself, but leave this
  502.              #  to the callers.
  503.              #
  504.              if newfaces is None:
  505.                  quarkx.msgbox("Face can't move because of locks",
  506.                      MT_ERROR, MB_OK)
  507.                  return
  508.              #
  509.              # swap them into the map
  510.              #
  511.              undo=quarkx.action()
  512.              for i in range(len(oldfaces)):
  513.                 undo.exchange(oldfaces[i], newfaces[i])
  514.              editor.ok(undo, "Move vertex")
  515.              #
  516.              # check for lost vertex
  517.              #
  518.              newpos = pack.pos+delta
  519.              if not freezelist:
  520.                for face in newfaces:
  521.                  for vtx in face.verticesof(pack.poly):
  522.                      if abs(newpos-vtx)<.01:
  523.                          break
  524.                  else:
  525.                      #
  526.                      # For some unknown magical reason, the appearance
  527.                      #  of this dialog causes the mov
  528.                      #
  529.                      if not src["sloppy"]:
  530.                          quarkx.msgbox("Moving Vertex Lost",MT_INFORMATION,MB_OK)
  531.                  break
  532.                  
  533.              #
  534.              # Now put the replacement info into pack (if
  535.              #  this isn't done, undo won't work right for
  536.              #  repeat entry of data info dialog
  537.              #
  538.              pack.moving = newfaces
  539.              pack.pos = newpos
  540.              #
  541.              # For some unkoown reason, the exchange operation
  542.              #  above causes the new stuff to become the selection;
  543.              #  so we set things back the way they were
  544.              #
  545.              editor.layout.explorer.sellist=[pack.poly]
  546.              #
  547.              # and reset the options in case we've changed them
  548.              #
  549.              options = quarkx.setupsubset(SS_MAP, "Options")
  550.              options["movevertex_gridpos"]=self.src["gridpos"]
  551.              options["movevertex_griddel"]=self.src["griddel"]
  552.              options["movevertex_sloppy"]=self.src["sloppy"]
  553.              
  554.          #
  555.          # This is an optional callback for final cleanup
  556.          #
  557.          def onclosing(self, editor=editor):
  558.              delAttr(editor,'movingvertex')
  559.              editor.invalidateviews()
  560.          
  561.          #
  562.          # And at least create the dialog.
  563.          # quarkx.clickform is the window last clicked in,
  564.          #  needed here by the rules of Black Magic
  565.          # 'vtxdrag' is the tag under which the dimensions
  566.          #  of the box are retained in setup.qrk (value of
  567.          #  dlgdim_vtxdrag specific); to check the size that
  568.          #  the dialog definition above is producing (size),
  569.          #  delete this from setup.qrk after closing quark,
  570.          #  and then reopen & fire up the dialog.
  571.          # Then editor is required, and the first two `callback'
  572.          #  functions we've defined, and the last as an option.
  573.          #
  574.          VtxDragDlg(quarkx.clickform, 'vtxdrag', editor, setup, action, onclosing)
  575.              
  576.     #
  577.     # And now a bunch of simple litte menu item callbacks
  578.     #
  579.     def lockclick(m, self=self, editor=editor):
  580.         try:
  581.             editor.lockedVertices.append(self)
  582.         except (AttributeError):
  583.             editor.lockedVertices = [self]
  584.         #
  585.         # redraw the views to see the effect.
  586.         #
  587.         editor.invalidateviews()
  588.         
  589.     def clearclick(m, self=self, editor=editor):
  590.         delAttr(editor,'lockedVertices')
  591.         delAttr(editor,'frozenFaces')
  592.         editor.invalidateviews()
  593.     
  594.     def unlockclick(m, editor=editor):
  595.         removeFromAttr(editor,'lockedVertices',m.unlockMe)
  596. #        editor.lockedVertices.remove(m.unlockMe)
  597. #        if editor.lockedVertices == []:
  598. #            del editor.lockedVertices
  599.         editor.invalidateviews()
  600.  
  601.  
  602.     #
  603.     # Moving a containing group so that the vertex shifts to ongrid
  604.     #
  605.     def moveparentpopup(self=self,editor=editor):
  606.         shift=self.pos-editor.aligntogrid(self.pos)
  607.  
  608.         def makeitem(object,editor,r,shift=shift):
  609.  
  610.             def Shifter(m, object=object, editor=editor, shift=shift):
  611.                 new=object.copy()
  612.                 undo=quarkx.action()
  613.                 new.translate(shift)
  614.                 undo.exchange(object, new)
  615.                 editor.ok(undo, "Move object")
  616.                 editor.invalidateviews()
  617.  
  618.             item = qmenu.item(object.name,Shifter, "Move me")
  619.             item.menuicon = object.geticon(1)
  620.             return item
  621.             
  622.         poly=self.poly
  623.         list=guiutils.buildParentPopupList(self.poly,makeitem, editor)
  624.         return list
  625.      
  626.     #
  627.     # And their menu items
  628.     #
  629.     moveparentitem = qmenu.popup("&Move Containing", moveparentpopup(),
  630.       hint="|The clicked-on containing object of this vertex will be moved so as to force the vertex onto the grid.")
  631.     moveitem = qmenu.item("&Move Vertex", moveclick)
  632.     lockitem = qmenu.item("&Lock Vertex", lockclick)
  633.     unlockitem = qmenu.item("&Unlock Vertex", unlockclick)
  634.     clearitem = qmenu.item("&Clear Locks", clearclick)
  635.     #
  636.     # And a bit of convoluted logic for enable/disable
  637.     #
  638.     locker = lockitem
  639.     try:
  640.         locklist = editor.lockedVertices
  641.     except (AttributeError):
  642.         pass
  643.     else:
  644.         for vtxh in locklist:
  645.             if not(vtxh.pos-self.pos):
  646.                 unlockitem.unlockMe = vtxh
  647.                 locker = unlockitem
  648.                 moveitem.state = qmenu.disabled
  649.                 break
  650.     #
  651.     # And we return the menu, the new items stuck onto the
  652.     #  front of the old.
  653.     #
  654.     return [moveparentitem, moveitem, locker, clearitem]+oldmenu(self,editor,view)
  655.     
  656. #
  657. # And here's the magic bit; when vertexmenu got defined, the
  658. #  original menu function for quarkpy.maphandles.VertexHandle
  659. #  got stored within it (as `oldmenu'); now we replace
  660. #  it in the quarkpy.maphandles.VertexHandle with out new
  661. #  creation
  662. #
  663. quarkpy.maphandles.VertexHandle.menu = vertexmenu
  664.  
  665. #
  666. # Should be generalized from tagging
  667. #
  668.  
  669. #
  670. # And a different version of the same trick to get the little
  671. #  blue squares drawn around the locked vertices, this time by
  672. #  replacing quarkpy.qbaseeditor.BaseEditor.finishdrawing
  673. #
  674. # Also the green square around the moving vertex
  675. #
  676. from tagging import drawredface # misnamed, oh well
  677.  
  678. def lockfinishdrawing(editor, view, oldmore=quarkpy.qbaseeditor.BaseEditor.finishdrawing):
  679.       cv = view.canvas()
  680.       try:
  681.          locks = editor.lockedVertices
  682.       except (AttributeError):
  683.          pass
  684.       else:
  685.          cv.pencolor = MapColor("Duplicator")
  686.          for vtxh in locks: # these are handles
  687.              p1 = view.proj(vtxh.pos)
  688.              tagging.drawsquare(cv,p1,8)
  689.       try:
  690.          moving = editor.movingvertex
  691.          p1 = view.proj(moving)
  692.       except (AttributeError):
  693.          pass
  694.       else:
  695.          if view.info["type"] == "3D":
  696.               scalefactor = 50
  697.          else:
  698.              scalefactor = 30
  699.          scale = view.scale(moving)
  700.          for (color, axis) in (MapColor("Tag"), (1,0,0)), (MapColor("Bezier"), (0,1,0)),(MapColor("Duplicator"), (0,0,1)):
  701.              cv.pencolor = color
  702.              p0 = view.proj(moving)
  703.              p1 = view.proj(moving+(scalefactor/scale)*quarkx.vect(axis))
  704.              cv.line(p0, p1)
  705.                  
  706. #         else:
  707. #             cv.pencolor = MapColor("Bezier")
  708. #             tagging.drawsquare(cv,p1,8)
  709.               
  710.  
  711.       cv.pencolor=MapColor("Duplicator")
  712.       try:
  713.           for face in editor.frozenFaces:
  714.               drawredface(view,cv,face)
  715.       except (AttributeError):
  716.           pass
  717.       
  718.       oldmore(editor, view)
  719.  
  720. quarkpy.qbaseeditor.BaseEditor.finishdrawing = lockfinishdrawing
  721.  
  722.  
  723. def vec2rads(v):
  724.     "returns pitch, yaw, in radians"
  725.     v = v.normalized
  726.     import math
  727.     pitch = -math.sin(v.z)
  728.     yaw = math.atan2(v.y, v.x)
  729.     return pitch, yaw
  730.  
  731. def find3DView(editor):
  732.     views = []
  733.     for v in editor.layout.views:
  734.         if v.info["type"]=="3D":
  735.             views.append(v)
  736.     if views == []:
  737.         return
  738.     return views[0]
  739.  
  740.  
  741. #
  742. # And now the whole bizness again to lock every vertex of a face
  743. #
  744. def lockfacemenu(o, editor, oldfacemenu = quarkpy.mapentities.FaceType.menu.im_func):
  745.     
  746.     def lockclick(m,face=o,editor=editor):
  747.         locks = getAttr(editor,'lockedVertices',[])
  748.         for poly in face.faceof:
  749.             for vtx in face.verticesof(poly):
  750.                 locks.append(quarkpy.maphandles.VertexHandle(vtx, poly))
  751.         editor.lockedVertices = locks
  752.         editor.invalidateviews()
  753.      
  754.     def unlockclick(m, face=o, editor=editor):
  755.         try:
  756.             locks = editor.lockedVertices
  757.         except (AttributeError):
  758.             return
  759.         for poly in face.faceof:
  760.             for vtx in face.verticesof(poly):
  761.                 for hvtx in locks[:]:
  762.                     if not (hvtx.pos-vtx):
  763.                         locks.remove(hvtx)
  764.         editor.invalidateviews()
  765.                         
  766.     def viewclick(m, face=o, editor=editor):
  767.         if quarkx.keydown('\020')==1: # shift is down
  768.             reverse = 1
  769.         else:
  770.             reverse = 0
  771.         clickview = quarkx.clickform.focus 
  772.         #
  773.         # clickform doesn't seem to work for floating 3d windows
  774.         #  so we just take the first.
  775.         #
  776.         if clickview is not None and clickview.info["type"]=="3D":
  777.             view = clickview
  778.         else:
  779.             view = find3DView(editor)
  780.             if view is None:
  781.                 quarkx.msgbox("Need an open 3D view for this one!",
  782.                    MT_ERROR,MB_OK)
  783.                 return
  784.         #
  785.         # Should have a 3D view here
  786.         #
  787.         pos, yaw, pitch = view.cameraposition
  788.         dist = abs(pos - face.origin)
  789.         if reverse:
  790.             norm = -face.normal
  791.         else:
  792.             norm = face.normal
  793.         newpos = face.origin+dist*(norm)
  794.         pitch, yaw = vec2rads(-norm)
  795.         view.cameraposition = newpos, yaw, pitch
  796.         editor.invalidateviews()
  797.  
  798.     def freezeclick(m, face=o, editor=editor):
  799.         appendToAttr(editor, 'frozenFaces', face)
  800.         editor.invalidateviews()
  801.         
  802.     def unfreezeclick(m, face=o, editor=editor):
  803.         removeFromAttr(editor, 'frozenFaces', face)
  804.         editor.invalidateviews()
  805.  
  806.     lockitem = qmenu.item("Lock Vertices",lockclick,"Locks all vertices on this face")
  807.     unlockitem = qmenu.item("Unlock Vertices", unlockclick,"Unlocks vertices on this face")
  808.     freezeitem = qmenu.item("Freeze Face", freezeclick,"|Plane of face doesn't move, so vertices are confined to move within it. (So they don't go exactly where they're told to).")
  809.     unfreezeitem = qmenu.item("Unfreeze Face", unfreezeclick, "|To unfreeze all frozen faces, clear locks on vertex menu.")
  810.     freezer = freezeitem
  811.     try:
  812.         freezelist = editor.frozenFaces
  813.     except (AttributeError):
  814.         pass
  815.     else:
  816.         for face in freezelist:
  817.             if o is face:
  818.                 freezer = unfreezeitem
  819.                 break
  820.                 
  821.     viewitem = qmenu.item("Look At", viewclick, "|An open 3D view shifts to look at this face head on.\n (SHIFT to look at the face from the back)")
  822.  
  823.     locking = qmenu.popup("Lock/Freeze",[lockitem,unlockitem, freezer],
  824.         hint = "|Submenu for items that are supposed to help in placing vertices by controlling which faces & vertices can move and which can't.")
  825.  
  826.     return [locking, viewitem]+oldfacemenu(o, editor)
  827.  
  828. quarkpy.mapentities.FaceType.menu = lockfacemenu
  829.  
  830.  
  831. #
  832. #  Code for looking at center of selection
  833. #
  834. def originmenu(self, editor, view, oldoriginmenu = quarkpy.qhandles.GenericHandle.OriginItems.im_func):
  835.   
  836.     menu = oldoriginmenu(self, editor, view)
  837.     
  838.     if view is not None:
  839.  
  840.       def seePointClick(m,self=self,editor=editor):
  841.         view = find3DView(editor)
  842.         pos, yaw, pitch = view.cameraposition
  843.         dir = (self.pos-pos).normalized
  844.         pitch, yaw = vec2rads(dir)
  845.         view.cameraposition = pos, yaw, pitch
  846.         editor.invalidateviews()
  847.  
  848.       seeitem = qmenu.item("Look To",seePointClick,"|Aims an open 3d view at object")
  849.     
  850.       menu[1:1] = [seeitem]
  851.  
  852.     return menu
  853.  
  854. quarkpy.qhandles.GenericHandle.OriginItems = originmenu
  855.  
  856.  
  857. #
  858. # Proper version of this now committed to main branch
  859. #
  860. #
  861. # 3d view camera circlestrafe
  862. #   This stuff is to be supported in qhandles as "C" mouse-drag
  863. #   option (Shift-LMB drag by default), so this code will
  864. #   be removed from the final version.
  865. #
  866.  
  867. def circleinit(self, editor, view, x, y, old = quarkpy.qhandles.SideStepDragObject.__init__):
  868.     self.editor = editor
  869.     old(self, editor, view, x, y)
  870.     
  871. quarkpy.qhandles.SideStepDragObject.__init__= circleinit
  872.     
  873. def circledragto(self, x, y, flags, olddragto=quarkpy.qhandles.SideStepDragObject.dragto):
  874.     sel = self.editor.layout.explorer.sellist
  875.     if sel and quarkx.keydown('Z')==1:
  876.         min, max = quarkx.boundingboxof(sel)
  877.         center = .5*(max+min)
  878.         pos, yaw, pitch = self.camerapos0
  879.         dist = abs(pos-center)
  880.         x = self.x0-x
  881.         y = self.y0-y
  882.         newdir = (pos + self.vleft*x + self.vtop*y - center).normalized
  883.         newpos = center+dist*newdir
  884.         pitch, yaw = vec2rads(-newdir)
  885.         self.view.animation = 1
  886.         self.view.cameraposition = newpos, yaw, pitch
  887.     else:
  888.         olddragto(self, x, y, flags)
  889.  
  890. quarkpy.qhandles.SideStepDragObject.dragto = circledragto
  891.  
  892. # $Log: mapmovevertex.py,v $
  893. # Revision 1.7  2002/05/18 22:38:31  tiglari
  894. # remove debug statement
  895. #
  896. # Revision 1.6  2002/04/01 08:30:05  tiglari
  897. # shift out the parentpopup menu stuff (to quarkpy.guiutils)
  898. #
  899. # Revision 1.5  2002/03/30 09:31:14  tiglari
  900. # Add 'move containing' item to the vertex RMB that moves a containing
  901. #   object so that the vertex becomes on-grid.
  902. #
  903. # Revision 1.4  2001/06/17 21:10:57  tiglari
  904. # fix button captions
  905. #
  906. # Revision 1.3  2001/06/16 03:19:05  tiglari
  907. # add Txt="" to separators that need it
  908. #
  909. # Revision 1.2  2001/05/24 22:28:05  tiglari
  910. # fix tuple bug, improved anti-drift
  911. #
  912. # Revision 1.1  2001/04/01 22:45:31  tiglari
  913. # initial commit
  914. #